home *** CD-ROM | disk | FTP | other *** search
/ Tech Win 1995 November / CD [TECH_B].bin / tech_b / delphi / trial / disk4 / doc.pak / DISPATCH.INT < prev    next >
Encoding:
Text File  |  1995-08-08  |  47.1 KB  |  947 lines
  1.  
  2. {*******************************************************}
  3. {                                                       }
  4. {       Delphi Runtime Library                          }
  5. {       Windows 3.1 API Interface Unit                  }
  6. {                                                       }
  7. {       Copyright (c) 1992,93 Borland International     }
  8. {                                                       }
  9. {*******************************************************}
  10.  
  11. Unit Dispatch;
  12.  
  13. interface
  14.  
  15. uses WinTypes, OLE2;
  16.  
  17. const
  18.   FADF_AUTO = 1; { array is allocated on the stack }
  19.   FADF_STATIC = 2; { array is staticly allocated }
  20.   FADF_EMBEDDED = 4; { array is embedded in a structure }
  21.   FADF_FIXEDSIZE = $10; { array may not be resized or reallocated }
  22.   FADF_BSTR = $100; { an array of BSTRs }
  23.   FADF_UNKNOWN = $200; { an array of IUnknown }
  24.   FADF_DISPATCH = $400; { an array of IDispatch }
  25.   FADF_VARIANT = $800; { an array of VARIANTs }
  26.   FADF_RESERVED = 61672; { bits reserved for future use }
  27.  
  28. {
  29.   VARENUM usage key,
  30.  
  31.     [V] - may appear in a VARIANT
  32.     [T] - may appear in a TYPEDESC
  33.     [P] - may appear in an OLE property set
  34.     [S] - may appear in a Safe Array
  35.  
  36. }
  37.   VT_EMPTY           = 0;   { [V]   [P]  nothing                     }
  38.   VT_NULL            = 1;   { [V]        SQL style Null              }
  39.   VT_I2              = 2;   { [V][T][P]  2 byte signed int           }
  40.   VT_I4              = 3;   { [V][T][P]  4 byte signed int           }
  41.   VT_R4              = 4;   { [V][T][P]  4 byte real                 }
  42.   VT_R8              = 5;   { [V][T][P]  8 byte real                 }
  43.   VT_CY              = 6;   { [V][T][P]  currency                    }
  44.   VT_DATE            = 7;   { [V][T][P]  date                        }
  45.   VT_BSTR            = 8;   { [V][T][P]  binary string               }
  46.   VT_DISPATCH        = 9;   { [V][T]     IDispatch FAR*              }
  47.   VT_ERROR           = 10;  { [V][T]     SCODE                       }
  48.   VT_BOOL            = 11;  { [V][T][P]  True=-1, False=0            }
  49.   VT_VARIANT         = 12;  { [V][T][P]  VARIANT FAR*                }
  50.   VT_UNKNOWN         = 13;  { [V][T]     IUnknown FAR*               }
  51.  
  52.   VT_I1              = 16;  {    [T]     signed char                 }
  53.   VT_UI1             = 17;  {    [T]     unsigned char               }
  54.   VT_UI2             = 18;  {    [T]     unsigned short              }
  55.   VT_UI4             = 19;  {    [T]     unsigned short              }
  56.   VT_I8              = 20;  {    [T][P]  signed 64-bit int           }
  57.   VT_UI8             = 21;  {    [T]     unsigned 64-bit int         }
  58.   VT_INT             = 22;  {    [T]     signed machine int          }
  59.   VT_UINT            = 23;  {    [T]     unsigned machine int        }
  60.   VT_VOID            = 24;  {    [T]     C style void                }
  61.   VT_HRESULT         = 25;  {    [T]                                 }
  62.   VT_PTR             = 26;  {    [T]     pointer type                }
  63.   VT_SAFEARRAY       = 27;  {    [T]     (use VT_ARRAY in VARIANT)   }
  64.   VT_CARRAY          = 28;  {    [T]     C style array               }
  65.   VT_USERDEFINED     = 29;  {    [T]     user defined type          }
  66.   VT_LPSTR           = 30;  {    [T][P]  null terminated string      }
  67.   VT_LPWSTR          = 31;  {    [T][P]  wide null terminated string }
  68.  
  69.   VT_FILETIME        = 64;  {       [P]  FILETIME                    }
  70.   VT_BLOB            = 65;  {       [P]  Length prefixed bytes       }
  71.   VT_STREAM          = 66;  {       [P]  Name of the stream follows  }
  72.   VT_STORAGE         = 67;  {       [P]  Name of the storage follows }
  73.   VT_STREAMED_OBJECT = 68;  {       [P]  Stream contains an object   }
  74.   VT_STORED_OBJECT   = 69;  {       [P]  Storage contains an object  }
  75.   VT_BLOB_OBJECT     = 70;  {       [P]  Blob contains an object     }
  76.   VT_CF              = 71;  {       [P]  Clipboard format            }
  77.   VT_CLSID           = 72;  {       [P]  A Class ID                  }
  78.  
  79.   VT_VECTOR          = $1000; {       [P]  simple counted array        }
  80.   VT_ARRAY           = $2000; { [V]        SAFEARRAY*                  }
  81.   VT_BYREF           = $4000; { [V]                                    }
  82.   VT_RESERVED        = $8000;
  83.  
  84.  
  85. { Variant access macros }
  86.  
  87.   STDOLE_MAJORVERNUM = 1;
  88.   STDOLE_MINORVERNUM = 0;
  89.   STDOLE_LCID = 0;
  90.  
  91. { OLE Automation error codes }
  92.  
  93.   DISP_E_UNKNOWNINTERFACE = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (1);
  94.   DISP_E_MEMBERNOTFOUND = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (3);
  95.   DISP_E_PARAMNOTFOUND = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (4);
  96.   DISP_E_TYPEMISMATCH = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (5);
  97.   DISP_E_UNKNOWNNAME = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (6);
  98.   DISP_E_NONAMEDARGS = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (7);
  99.   DISP_E_BADVARTYPE = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (8);
  100.   DISP_E_EXCEPTION = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (9);
  101.   DISP_E_OVERFLOW = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (10);
  102.   DISP_E_BADINDEX = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (11);
  103.   DISP_E_UNKNOWNLCID = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (12);
  104.   DISP_E_ARRAYISLOCKED = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (13);
  105.   DISP_E_BADPARAMCOUNT = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (14);
  106.   DISP_E_PARAMNOTOPTIONAL = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (15);
  107.   DISP_E_BADCALLEE = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (16);
  108.   DISP_E_NOTACOLLECTION = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (17);
  109.  
  110.   TYPE_E_BUFFERTOOSMALL = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (32790);
  111.   TYPE_E_INVDATAREAD = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (32792);
  112.   TYPE_E_UNSUPFORMAT = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (32793);
  113.   TYPE_E_REGISTRYACCESS = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (32796);
  114.   TYPE_E_LIBNOTREGISTERED = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (32797);
  115.   TYPE_E_UNDEFINEDTYPE = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (32807);
  116.   TYPE_E_QUALIFIEDNAMEDISALLOWED = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (32808);
  117.   TYPE_E_INVALIDSTATE = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (32809);
  118.   TYPE_E_WRONGTYPEKIND = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (32810);
  119.   TYPE_E_ELEMENTNOTFOUND = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (32811);
  120.   TYPE_E_AMBIGUOUSNAME = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (32812);
  121.   TYPE_E_NAMECONFLICT = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (32813);
  122.   TYPE_E_UNKNOWNLCID = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (32814);
  123.   TYPE_E_DLLFUNCTIONNOTFOUND = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (32815);
  124.   TYPE_E_BADMODULEKIND = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (35005);
  125.   TYPE_E_SIZETOOBIG = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (35013);
  126.   TYPE_E_DUPLICATEID = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (35014);
  127.   TYPE_E_INVALIDID = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (35023);
  128.   TYPE_E_TYPEMISMATCH = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (36000);
  129.   TYPE_E_OUTOFBOUNDS = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (36001);
  130.   TYPE_E_IOERROR = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (36002);
  131.   TYPE_E_CANTCREATETMPFILE = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (36003);
  132.   TYPE_E_CANTLOADLIBRARY = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (40010);
  133.   TYPE_E_INCONSISTENTPROPFUNCS = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (40067);
  134.   TYPE_E_CIRCULARTYPE = (SEVERITY_ERROR shl 31) or (FACILITY_DISPATCH shl 16) or (40068);
  135.  
  136. { if not already picked up from olenls.h }
  137.  
  138.   VARIANT_NOVALUEPROP = 1;
  139.   VAR_TIMEVALUEONLY = 1; { return time value }
  140.   VAR_DATEVALUEONLY = 2; { return date value }
  141.  
  142.   { DISPID reserved for the standard "value" property }
  143.   DISPID_VALUE = 0;
  144.  
  145.   { DISPID reserved to indicate an "unknown" name }
  146.   DISPID_UNKNOWN =  -1;
  147.  
  148.   { The following DISPID is reserved to indicate the param
  149.    that is the right-hand-side (or "put" value) of a PropertyPut }
  150.   DISPID_PROPERTYPUT = -3;
  151.  
  152.   { DISPID reserved for the standard "NewEnum" method }
  153.   DISPID_NEWENUM  = -4;
  154.  
  155.   { DISPID reserved for the standard "Evaluate" method }
  156.   DISPID_EVALUATE  = -5;
  157.   DISPID_CONSTRUCTOR = -6;
  158.   DISPID_DESTRUCTOR = -7;
  159.  
  160.   MEMBERID_NIL = DISPID_UNKNOWN;
  161.   ID_DEFAULTINST = -2;
  162.  
  163.   IDLFLAG_NONE = 0;
  164.   IDLFLAG_FIN = 1;
  165.   IDLFLAG_FOUT = 2;
  166.   IDLFLAG_FLCID = 4;
  167.   IDLFLAG_FRETVAL = 8;
  168.  
  169. { Flags for IDispatch::Invoke }
  170.  
  171.   DISPATCH_METHOD = 1;
  172.   DISPATCH_PROPERTYGET = 2;
  173.   DISPATCH_PROPERTYPUT = 4;
  174.   DISPATCH_PROPERTYPUTREF = 8;
  175.  
  176.   TYPEFLAG_FOLEAUTOMATION = $100;
  177.   TYPEFLAG_FNONEXTENSIBLE = $80;
  178.   TYPEFLAG_FDUAL = $40;
  179.   TYPEFLAG_FCONTROL = $20;
  180.   TYPEFLAG_FHIDDEN = $10;
  181.   TYPEFLAG_FPREDECLID = 8;
  182.   TYPEFLAG_FLICENSED = 4;
  183.   TYPEFLAG_FCANCREATE = 2;
  184.   TYPEFLAG_FAPPOBJECT = 1;
  185.  
  186.   FUNCFLAG_FHIDDEN = $40;
  187.   FUNCFLAG_FDEFAULTBIND = $20;
  188.   FUNCFLAG_FDISPLAYBIND = $10;
  189.   FUNCFLAG_FREQUESTEDIT = 8;
  190.   FUNCFLAG_FBINDABLE = 4;
  191.   FUNCFLAG_FSOURCE = 2;
  192.   FUNCFLAG_FRESTRICTED = 1;
  193.  
  194.   VARFLAG_FHIDDEN = $40;
  195.   VARFLAG_FDEFAULTBIND = $20;
  196.   VARFLAG_FDISPLAYBIND = $10;
  197.   VARFLAG_FREQUESTEDIT = 8;
  198.   VARFLAG_FBINDABLE = 4;
  199.   VARFLAG_FSOURCE = 2;
  200.   VARFLAG_FREADONLY = 1;
  201.  
  202.   IMPLTYPEFLAG_FDEFAULT = 1;
  203.   IMPLTYPEFLAG_FSOURCE = 2;
  204.   IMPLTYPEFLAG_FRESTRICTED = 4;
  205.  
  206.   { flags for RegisterActiveObject }
  207.   ACTIVEOBJECT_STRONG = 0;
  208.   ACTIVEOBJECT_WEAK = 1;
  209.  
  210.   { INVOKEKIND enum }
  211.   INVOKE_FUNC = 1;
  212.   INVOKE_PROPERTYGET = 2;
  213.   INVOKE_PROPERTYPUT = 4;
  214.   INVOKE_PROPERTYPUTREF = 8;
  215.  
  216.  
  217. type
  218.   BSTR = PChar;
  219.   POLESTR = PChar;
  220.   PCOLESTR = PChar;
  221.  
  222.   SAFEARRAYBOUND = record
  223.     cElements: Longint;
  224.     lLbound: Longint;
  225.   end;
  226.  
  227.   SAFEARRAY  = record
  228.     cDims: Longint;
  229.     fFeatures: Longint;
  230.     cbElements: Longint;
  231.     cLocks: Longint;
  232.     handle: Longint;
  233.     pvData: Pointer;
  234.     rgsabound: array [0..1] of SAFEARRAYBOUND;
  235.   end;
  236.  
  237.   VARIANT_BOOL = Integer;
  238.   DATE = Double;
  239.  
  240.   { This is a helper record for use in handling currency. }
  241.   CY = record
  242.     Lo: Longint;
  243.     Hi: Longint;
  244.   end;
  245.  
  246.   VARTYPE = Integer;
  247.   IDispatch = class;
  248.   PSAFEARRAY = ^SAFEARRAY;
  249.  
  250.   PARRAYDESC = ^ARRAYDESC;
  251.   PTYPEDESC = ^TYPEDESC;
  252.   PVARIANT = ^VARIANT;
  253.   VARIANT = record
  254.     vt: VARTYPE;
  255.     wReserved1: Word;
  256.     wReserved2: Word;
  257.     wReserved3: Word;
  258.    case Integer of
  259.       VT_I2:                 (iVal: Integer);          { VT_I2            }
  260.       VT_I4:                 (lVal: Longint);          { VT_I4            }
  261.       VT_R4:                 (fltVal: Single);         { VT_R4            }
  262.       VT_R8:                 (dblVal: Double);         { VT_R8            }
  263.       VT_BOOL:               (vbool: BOOL);            { VT_BOOL          }
  264.       VT_ERROR:              (scode: SCODE);           { VT_ERROR         }
  265.       VT_CY:                 (cyVal: CY);              { VT_CY            }
  266.       VT_DATE:               (date: DATE);             { VT_DATE          }
  267.       VT_BSTR:               (bstrVal: BSTR);          { VT_BSTR          }
  268.       VT_UNKNOWN:            (punkVal: IUnknown);      { VT_UNKNOWN       }
  269.       VT_DISPATCH:           (pdispVal: IDispatch);    { VT_DISPATCH      }
  270.       VT_ARRAY:              (parray: SAFEARRAY);      { VT_ARRAY|*       }
  271.       VT_BYREF or VT_I2:         (piVal: ^Integer);    { VT_BYREF|VT_I2   }
  272.       VT_BYREF or VT_I4:         (plVal: ^Longint);    { VT_BYREF|VT_I4   }
  273.       VT_BYREF or VT_R4:         (pfltVal: ^Single);   { VT_BYREF|VT_R4   }
  274.       VT_BYREF or VT_R8:         (pdblVal: ^Double);   { VT_BYREF|VT_R8   }
  275.       VT_BYREF or VT_BOOL:       (pbool: ^BOOL);       { VT_BYREF|VT_BOOL }
  276.       VT_BYREF or VT_ERROR:      (pscode: ^SCODE);     { VT_BYREF|VT_ERROR}
  277.       VT_BYREF or VT_CY:         (pcyVal:  ^CY);       { VT_BYREF|VT_CY   }
  278.       VT_BYREF or VT_DATE:       (pdate: ^DATE);       { VT_BYREF|VT_DATE }
  279.       VT_BYREF or VT_BSTR:       (pbstrVal: ^BSTR);    { VT_BYREF|VT_BSTR }
  280.       VT_BYREF or VT_UNKNOWN:   (ppunkVal: ^IUnknown); { VT_BYREF|VT_UNKNOWN}
  281.       VT_BYREF or VT_DISPATCH:   (ppdispVal: ^IDispatch);{ VT_BYREF|VT_DISPATCH}
  282.       VT_BYREF or VT_ARRAY:      (pparray: ^SAFEARRAY);  { VT_BYREF|VT_ARRAY|* }
  283.       VT_BYREF or VT_VARIANT:    (pvarVal: PVARIANT);    { VT_BYREF|VT_VARIANT }
  284.   end;
  285.  
  286.   VARIANTARG = VARIANT;
  287.   PVARIANTARG = ^VARIANTARG;
  288.  
  289.   LCID = Longint;
  290.   PSAFEARRAYBOUND = ^SAFEARRAYBOUND;
  291.   PHRESULT = ^HRESULT;
  292.  
  293. {---------------------------------------------------------------------}
  294. {                             ITypeLib                                }
  295. {---------------------------------------------------------------------}
  296.  
  297.   DISPID = Longint;
  298.   MEMBERID = DISPID;
  299.   SYSKIND = (SYS_WIN16, SYS_WIN32, SYS_MAC);
  300.   LIBFLAGS = (LIBFLAG_ZERO, LIBFLAG_FRESTRICTED, LIBFLAG_FCONTROL,
  301.     LIBFLAG_THREE, LIBFLAG_FHIDDEN);
  302.  
  303.   PTLIBATTR = ^TLIBATTR;
  304.   TLIBATTR = record
  305.     guid: GUID; { globally unique library id }
  306.     lcid: LCID; { locale of the TypeLibrary }
  307.     syskind: SYSKIND; 
  308.     wMajorVerNum: Word; 
  309.     wMinorVerNum: Word; 
  310.     wLibFlags: Word; 
  311.   end;
  312.  
  313.   TYPEKIND = (TKIND_ENUM, TKIND_RECORD, TKIND_MODULE, TKIND_INTERFACE, TKIND_DISPATCH,
  314.     TKIND_COCLASS, TKIND_ALIAS, TKIND_UNION, TKIND_MAX);
  315.  
  316.   ITypeInfo = class;
  317.   ITypeComp = class;
  318.   ITypeLib = class(IUnknown)
  319.     function QueryInterface(const riid: IID; var ppvObj: Pointer): HResult; virtual; cdecl; export; abstract;
  320.     function AddRef: Longint; virtual; cdecl; export; abstract;
  321.     function Release: Longint; virtual; cdecl; export; abstract;
  322.     function GetTypeInfoCount: Integer; virtual; cdecl; export; abstract;
  323.     function GetTypeInfo(index: Integer; var pptinfo: ITypeInfo): HResult; virtual; cdecl; export; abstract;
  324.     function GetTypeInfoType(index: Integer; var ptypekind: TYPEKIND): HResult;
  325.       virtual; cdecl; export; abstract;
  326.     function GetTypeInfoOfGuid(const guid: IID; var pptinfo: ITypeInfo): HResult;
  327.       virtual; cdecl; export; abstract;
  328.     function GetLibAttr(var pptlibattr: PTLIBATTR): HResult; virtual; cdecl; export; abstract;
  329.     function GetTypeComp(var pptcomp: ITypeComp): HResult; virtual; cdecl; export; abstract;
  330.     function GetDocumentation(index: Integer; var pbstrName: BSTR; 
  331.       var pbstrDocString: BSTR; var pdwHelpContext: Longint; 
  332.       var pbstrHelpFile: BSTR): HResult; virtual; cdecl; export; abstract;
  333.     function IsName(szNameBuf: PChar; lHashVal: Longint; var lpfName: Integer): HResult;
  334.       virtual; cdecl; export; abstract;
  335.     function FindName(szNameBuf: PChar; lHashVal: Longint; var rgptinfo: ITypeInfo;
  336.       var rgmemid: MEMBERID; var pcFound: Word): HResult; virtual; cdecl; export; abstract;
  337.     procedure ReleaseTLibAttr(var ptlibattr: TLIBATTR); virtual; cdecl; export; abstract;
  338.   end;
  339.  
  340.  
  341. {---------------------------------------------------------------------}
  342. {                            ITypeInfo                                }
  343. {---------------------------------------------------------------------}
  344.  
  345.   HREFTYPE = Longint;
  346.  
  347.   TYPEDESC = record 
  348.     case Integer of
  349.       VT_PTR:         (ptdesc: PTYPEDESC; vt: VARTYPE);
  350.       VT_CARRAY:       (padesc: PARRAYDESC);
  351.       VT_USERDEFINED: (hreftype: HREFTYPE);
  352.     {vt: VARTYPE; ICS! }
  353.   end;
  354.  
  355.   ARRAYDESC = record 
  356.      tdescElem: TYPEDESC;    { element type }
  357.      cDims: Word;  { dimension count }
  358.      rgbounds: array [0..1] of SAFEARRAYBOUND;  { variable length array of bounds }
  359.   end;
  360.  
  361.   IDLDESC = record 
  362.      bstrIDLInfo: BSTR; { reserved, but original name retained for compatibilty }
  363.      wIDLFlags: Word;  { IN, OUT, etc }
  364.   end;
  365.  
  366.   PELEMDESC = ^ELEMDESC; 
  367.   ELEMDESC = record 
  368.      tdesc: TYPEDESC;    { the type of the element }
  369.      idldesc: IDLDESC;    { info for remoting the element } 
  370.   end;
  371.  
  372.   PTYPEATTR = ^TYPEATTR;
  373.   TYPEATTR = record 
  374.      guid: GUID;      { the GUID of the TypeInfo }
  375.      lcid: LCID;      { locale of member names and doc strings }
  376.      dwReserved: Longint;
  377.      memidConstructor: MEMBERID;  { ID of constructor, MEMBERID_NIL if none }
  378.      memidDestructor: MEMBERID;  { ID of destructor, MEMBERID_NIL if none }
  379.      pstrSchema: PChar;  { reserved for future use }
  380.      cbSizeInstance: Longint;{ the size of an instance of this type }
  381.      typekind: TYPEKIND;    { the kind of type this typeinfo describes }
  382.      cFuncs: Word;  { number of functions }
  383.      cVars: Word;  { number of variables / data members }
  384.      cImplTypes: Word;  { number of implemented interfaces }
  385.      cbSizeVft: Word;  { the size of this types virtual func table }
  386.      cbAlignment: Word;  { the alignment for an instance of this type }
  387.      wTypeFlags: Word;
  388.      wMajorVerNum: Word;{ major version number }
  389.      wMinorVerNum: Word;{ minor version number }
  390.      tdescAlias: TYPEDESC;  { if typekind == TKIND_ALIAS this specifies
  391.                               the type for which this type is an alias }
  392.      idldescType: IDLDESC;        { IDL attributes of the described type }
  393.   end;
  394.  
  395.   DISPPARAMS = record
  396.      rgvarg: PVARIANTARG;
  397.      rgdispidNamedArgs: ^DISPID;
  398.      cArgs: Word;
  399.      cNamedArgs: Word;
  400.   end;
  401.  
  402.   PEXEPINFO = ^EXCEPINFO;
  403.   TfnDeferredFillIn = function(ExInfo: PEXEPINFO): HResult;
  404.   EXCEPINFO = record 
  405.      wCode: Word;             { An error code describing the error. }
  406.               { Either (but not both) the wCode or }
  407.               { scode fields must be set }
  408.      wReserved: Word;
  409.  
  410.      { A textual, human readable name of the source of the exception. 
  411.        It is up to the IDispatch implementor to fill this in.
  412.        Typically this will be an application name. }
  413.      bstrSource: BSTR;
  414.  
  415.      { A textual, human readable description of the error. 
  416.        If no description is available, NULL should be used. }
  417.      bstrDescription: BSTR;
  418.  
  419.      { Fully qualified drive, path, and file name of a help file with more 
  420.        information about the error.  If no help is available, NULL should be used. }
  421.      bstrHelpFile: BSTR;
  422.  
  423.      dwHelpContext: Longint;  { help context of topic within the help file. }
  424.      pvReserved: Pointer;
  425.  
  426.     { Use of this field allows an application to defer filling in
  427.        the bstrDescription, bstrHelpFile, and dwHelpContext fields
  428.        until they are needed.  This field might be used, for example,
  429.        if loading the string for the error is a time-consuming
  430.        operation. If deferred fill-in is not desired, this field should
  431.        be set to NULL. }
  432.      pfnDeferredFillIn: TfnDeferredFillIn;
  433.  
  434.      scode: SCODE;    { An SCODE describing the error. }
  435.   end;
  436.  
  437.   CALLCONV = (CC_ZERO, CC_CDECL, CC_PASCAL, CC_MACPASCAL, CC_STDCALL, CC_RESERVED,
  438.     CC_SYSCALL, CC_MPWCDECL, CC_MPWPASCAL, CC_MAX);
  439.   FUNCKIND = (FUNC_VIRTUAL, FUNC_PUREVIRTUAL, FUNC_NONVIRTUAL, FUNC_STATIC, FUNC_DISPATCH);
  440.   INVOKEKIND = Integer;
  441.  
  442.   PFUNCDESC = ^FUNCDESC;
  443.   FUNCDESC = record 
  444.      memid: MEMBERID;
  445.      lprgscode: ^SCODE;
  446.      lprgelemdescParam: PELEMDESC;  { array of parameter types }
  447.      fkind: FUNCKIND;
  448.      ikind: INVOKEKIND;
  449.      cconv: CALLCONV;
  450.      cParams: Integer;
  451.      cParamsOpt: Integer;
  452.      oVft: Integer;
  453.      cScodes: Integer;
  454.      elemdescFunc: ELEMDESC;
  455.      wFuncFlags: Word;
  456.   end;
  457.  
  458.   VARKIND = (VAR_PERINSTANCE, VAR_STATIC, VAR_CONST, VAR_DISPATCH);
  459.  
  460.   PVARDESC = ^VARDESC;
  461.   VARDESC = record 
  462.     memid: MEMBERID;
  463.     lpstrSchema: PChar;    { reserved for future use }
  464.     case Integer of
  465.       VAR_PERINSTANCE: (oInst: Longint; elemdescVar: ELEMDESC; wVarFlags: Word; vk: VARKIND); 
  466.       VAR_CONST: (lpvarValue: PVARIANT); { - the value of the constant }
  467.     {elemdescVar: ELEMDESC;
  468.     wVarFlags: Word;
  469.     varkind: VARKIND; ICS! }
  470.   end;
  471.  
  472.   ITypeInfo = class(IUnknown)
  473.     function QueryInterface(const riid: IID; var ppvObj: Pointer): HResult; 
  474.       virtual; cdecl; export; abstract;
  475.     function AddRef: Longint; virtual; cdecl; export; abstract;
  476.     function Release: Longint; virtual; cdecl; export; abstract;
  477.     function GetTypeAttr(var pptypeattr: PTYPEATTR): HResult; virtual; cdecl; export; abstract;
  478.     function GetTypeComp(var pptcomp: ITypeComp): HResult; virtual; cdecl; export; abstract;
  479.     function GetFuncDesc(index: Integer; var ppfuncdesc: PFUNCDESC): HResult; 
  480.       virtual; cdecl; export; abstract;
  481.     function GetVarDesc(index: Integer; var ppvardesc: PVARDESC): HResult; 
  482.       virtual; cdecl; export; abstract;
  483.     function GetNames(memid: MEMBERID; var rgbstrNames: BSTR; cMaxNames: Integer; 
  484.       var pcNames: Integer): HResult; virtual; cdecl; export; abstract;
  485.     function GetRefTypeOfImplType(index: Integer; var phreftype: HREFTYPE): HResult;
  486.       virtual; cdecl; export; abstract;
  487.     function GetImplTypeFlags(index: Integer; var pimpltypeflags: Integer): HResult; 
  488.       virtual; cdecl; export; abstract;
  489.     function GetIDsOfNames(var rgszNames: PChar; cNames: Integer; 
  490.       var rgmemid: MEMBERID): HResult; virtual; cdecl; export; abstract;
  491.     function Invoke(pvInstance: Pointer; memid: MEMBERID; wFlags: Word; 
  492.       var pdispparams: DISPPARAMS; var pvarResult: VARIANT; 
  493.       var pexcepinfo: EXCEPINFO; var puArgErr: Integer): HResult; virtual; cdecl; export; abstract;
  494.     function GetDocumentation(memid: MEMBERID; var pbstrName: BSTR; 
  495.       var pbstrDocString: BSTR; var pdwHelpContext: Longint; 
  496.       var pbstrHelpFile: BSTR): HResult; virtual; cdecl; export; abstract;
  497.     function GetDllEntry(memid: MEMBERID; invkind: INVOKEKIND; 
  498.       var pbstrDllName: BSTR; var pbstrName: BSTR; var pwOrdinal: Word): HResult; 
  499.       virtual; cdecl; export; abstract;
  500.     function GetRefTypeInfo(hreftype: HREFTYPE; var pptinfo: ITypeInfo): HResult;
  501.       virtual; cdecl; export; abstract;
  502.     function AddressOfMember(memid: MEMBERID; invkind: INVOKEKIND; 
  503.       var ppv: Pointer): HResult; virtual; cdecl; export; abstract;
  504.     function CreateInstance(var punkOuter: IUnknown; const riid: IID; 
  505.       var ppvObj: Pointer): HResult; virtual; cdecl; export; abstract;
  506.     function GetMops(memid: MEMBERID; var pbstrMops: BSTR): HResult;
  507.       virtual; cdecl; export; abstract;
  508.     function GetContainingTypeLib(var pptlib: ITypeLib; var pindex: Integer): HResult;
  509.       virtual; cdecl; export; abstract;
  510.     procedure ReleaseTypeAttr(var ptypeattr: TYPEATTR); virtual; cdecl; export; abstract;
  511.     procedure ReleaseFuncDesc(var pfuncdesc: FUNCDESC); virtual; cdecl; export; abstract;
  512.     procedure ReleaseVarDesc(var pvardesc: VARDESC); virtual; cdecl; export; abstract;
  513.   end;
  514.  
  515.   PDISPPARAMS = ^DISPPARAMS;
  516.  
  517. {---------------------------------------------------------------------}
  518. {                            ITypeComp                                }
  519. {---------------------------------------------------------------------}
  520.  
  521.   DESCKIND = (DESCKIND_NONE, DESCKIND_FUNCDESC, DESCKIND_VARDESC, DESCKIND_TYPECOMP,
  522.     DESCKIND_IMPLICITAPPOBJ, DESCKIND_MAX);
  523.  
  524.   BINDPTR = record
  525.     case Integer of
  526.     1: (lpfuncdesc: PFUNCDESC); 
  527.     2: (lpvardesc: PVARDESC); 
  528.     3: (lptcomp: ITypeComp); 
  529.   end;
  530.  
  531. { ITypeComp methods }
  532.  
  533.   ITypeComp = class(IUnknown)
  534.     function QueryInterface(const riid: IID; var ppvObj: Pointer): HResult; 
  535.                          virtual; cdecl; export; abstract;
  536.     function AddRef: Longint; virtual; cdecl; export; abstract;
  537.     function Release: Longint; virtual; cdecl; export; abstract;
  538.     function Bind(szName: PChar; lHashVal: Longint; wflags: Word; var pptinfo: 
  539.                          ITypeInfo; var pdesckind: DESCKIND; var pbindptr: 
  540.                          BINDPTR): HResult; virtual; cdecl; export; abstract;
  541.     function BindType(szName: PChar; lHashVal: Longint; var pptinfo: ITypeInfo;
  542.                          var pptcomp: ITypeComp): HResult; virtual; cdecl; 
  543.                          export; abstract;
  544.   end;
  545.  
  546. {---------------------------------------------------------------------}
  547. {                         ICreateTypeLib                              }
  548. {---------------------------------------------------------------------}
  549.  
  550.   ICreateTypeInfo = class;
  551.   ICreateTypeLib = class(IUnknown)
  552.     function QueryInterface(const riid: IID; var ppvObj: Pointer): HResult; 
  553.       virtual; cdecl; export; abstract;
  554.     function AddRef: Longint; virtual; cdecl; export; abstract;
  555.     function Release: Longint; virtual; cdecl; export; abstract;
  556.     function CreateTypeInfo(szName: PChar; tkind: TYPEKIND; 
  557.       var lplpictinfo: ICreateTypeInfo): HResult; virtual; cdecl; export; abstract;
  558.     function SetName(szName: PChar): HResult; virtual; cdecl; export; abstract;
  559.     function SetVersion(wMajorVerNum: Word; wMinorVerNum: Word): HResult; virtual; cdecl; export; abstract;
  560.     function SetGuid(const guid: IID): HResult; virtual; cdecl; export; abstract;
  561.     function SetDocString(szDoc: PChar): HResult; virtual; cdecl; export; abstract;
  562.     function SetHelpFileName(szHelpFileName: PChar): HResult; virtual; cdecl; export; abstract;
  563.     function SetHelpContext(dwHelpContext: Longint): HResult; virtual; cdecl; export; abstract;
  564.     function SetLcid(lcid: LCID): HResult; virtual; cdecl; export; abstract;
  565.     function SetLibFlags(uLibFlags: Integer): HResult; virtual; cdecl; export; abstract;
  566.     function SaveAllChanges: HResult; virtual; cdecl; export; abstract;
  567.   end;
  568.  
  569.   LPCREATETYPELIB = ^ICreateTypeLib;
  570.  
  571. {---------------------------------------------------------------------}
  572. {                         ICreateTypeInfo                             }
  573. {---------------------------------------------------------------------}
  574.  
  575. { ICreateTypeInfo methods }
  576.  
  577.   ICreateTypeInfo = class(IUnknown)
  578.     function QueryInterface(const riid: IID; var ppvObj: Pointer): HResult; 
  579.       virtual; cdecl; export; abstract;
  580.     function AddRef: Longint; virtual; cdecl; export; abstract;
  581.     function Release: Longint; virtual; cdecl; export; abstract;
  582.     function SetGuid(const guid: IID): HResult; virtual; cdecl; export; abstract;
  583.     function SetTypeFlags(uTypeFlags: Integer): HResult; virtual; cdecl; export; abstract;
  584.     function SetDocString(pstrDoc: PChar): HResult; virtual; cdecl; export; abstract;
  585.     function SetHelpContext(dwHelpContext: Longint): HResult; virtual; cdecl; export; abstract;
  586.     function SetVersion(wMajorVerNum: Word; wMinorVerNum: Word): HResult; 
  587.       virtual; cdecl; export; abstract;
  588.     function AddRefTypeInfo(ptinfo: ITypeInfo; var phreftype: HREFTYPE): HResult;
  589.       virtual; cdecl; export; abstract;
  590.     function AddFuncDesc(index: Integer; var pfuncdesc: FUNCDESC): HResult; 
  591.       virtual; cdecl; export; abstract;
  592.     function AddImplType(index: Integer; hreftype: HREFTYPE): HResult; 
  593.       virtual; cdecl; export; abstract;
  594.     function SetImplTypeFlags(index: Integer; impltypeflags: Integer): HResult;
  595.       virtual; cdecl; export; abstract;
  596.     function SetAlignment(cbAlignment: Word): HResult; virtual; cdecl; export; abstract;
  597.     function SetSchema(lpstrSchema: PChar): HResult; virtual; cdecl; export; abstract;
  598.     function AddVarDesc(index: Integer; var pvardesc: VARDESC): HResult; 
  599.       virtual; cdecl; export; abstract;
  600.     function SetFuncAndParamNames(index: Integer; var rgszNames: PChar; 
  601.       cNames: Integer): HResult; virtual; cdecl; export; abstract;
  602.     function SetVarName(index: Integer; szName: PChar): HResult; virtual; cdecl; export; abstract;
  603.     function SetTypeDescAlias(var ptdescAlias: TYPEDESC): HResult; virtual; cdecl; export; abstract;
  604.     function DefineFuncAsDllEntry(index: Integer; szDllName: PChar; 
  605.       szProcName: PChar): HResult; virtual; cdecl; export; abstract;
  606.     function SetFuncDocString(index: Integer; szDocString: PChar): HResult; 
  607.       virtual; cdecl; export; abstract;
  608.     function SetVarDocString(index: Integer; szDocString: PChar): HResult; 
  609.       virtual; cdecl; export; abstract;
  610.     function SetFuncHelpContext(index: Integer; dwHelpContext: Longint): HResult;
  611.       virtual; cdecl; export; abstract;
  612.     function SetVarHelpContext(index: Integer; dwHelpContext: Longint): HResult;
  613.       virtual; cdecl; export; abstract;
  614.     function SetMops(index: Integer; bstrMops: BSTR): HResult; virtual; cdecl; export; abstract;
  615.     function SetTypeIdldesc(var pidldesc: IDLDESC): HResult; virtual; cdecl; export; abstract;
  616.     function LayOut: HResult; virtual; cdecl; export; abstract;
  617.   end;
  618.  
  619.   PIDLDESC = ^IDLDESC;
  620.   LPCREATETYPEINFO = ^ICreateTypeInfo;
  621.  
  622. {---------------------------------------------------------------------}
  623. {                          IEnumVARIANT                               }
  624. {---------------------------------------------------------------------}
  625.  
  626.   IEnumVARIANT = class(IUnknown)
  627.     function QueryInterface(const riid: IID; var ppvObj: Pointer): HResult; 
  628.       virtual; cdecl; export; abstract;
  629.     function AddRef: Longint; virtual; cdecl; export; abstract;
  630.     function Release: Longint; virtual; cdecl; export; abstract;
  631.     function Next(celt: Longint; var rgvar: VARIANT; 
  632.       var pceltFetched: Longint): HResult; virtual; cdecl; export; abstract;
  633.     function Skip(celt: Longint): HResult; virtual; cdecl; export; abstract;
  634.     function Reset: HResult; virtual; cdecl; export; abstract;
  635.     function Clone(var ppenum: IEnumVARIANT): HResult; virtual; cdecl; export; abstract;
  636.   end;
  637.  
  638. {---------------------------------------------------------------------}
  639. {                             IDispatch                               }
  640. {---------------------------------------------------------------------}
  641.  
  642. { IDispatch methods }
  643.  
  644.   IDispatch = class(IUnknown)
  645.     function QueryInterface(const riid: IID; var ppvObj: Pointer): HResult; 
  646.       virtual; cdecl; export; abstract;
  647.     function AddRef: Longint; virtual; cdecl; export; abstract;
  648.     function Release: Longint; virtual; cdecl; export; abstract;
  649.     function GetTypeInfoCount(var pctinfo: Integer): HResult; virtual; cdecl; export; abstract;
  650.     function GetTypeInfo(itinfo: Integer; lcid: LCID; var pptinfo: ITypeInfo): HResult; virtual; cdecl; export; abstract;
  651.     function GetIDsOfNames(const riid: IID; var rgszNames: PChar; 
  652.       cNames: Integer; lcid: LCID; var rgdispid: DISPID): HResult; virtual; cdecl; export; abstract;
  653.     function Invoke(dispidMember: DISPID; const riid: IID; lcid: LCID; 
  654.       wFlags: Word; var pdispparams: DISPPARAMS; var pvarResult: VARIANT; 
  655.       var pexcepinfo: EXCEPINFO; var puArgErr: Integer): HResult; virtual; cdecl; export; abstract;
  656.   end;
  657.  
  658.   LPDISPATCH = ^IDispatch;
  659.  
  660. {---------------------------------------------------------------------}
  661. {                      IErrorInfo, et al}
  662. {---------------------------------------------------------------------}
  663.  
  664. { IErrorInfo methods }
  665.  
  666.   IErrorInfo = class(IUnknown)
  667.     function QueryInterface(const riid: IID; var ppvObj: Pointer): HResult; virtual; cdecl; export; abstract;
  668.     function AddRef: Longint; virtual; cdecl; export; abstract;
  669.     function Release: Longint; virtual; cdecl; export; abstract;
  670.     function GetGUID(var pguid: GUID): HResult; virtual; cdecl; export; abstract;
  671.     function GetSource(var pbstrSource: BSTR): HResult; virtual; cdecl; export; abstract;
  672.     function GetDescription(var pbstrDescription: BSTR): HResult; virtual; cdecl; export; abstract;
  673.     function GetHelpFile(var pbstrHelpFile: BSTR): HResult; virtual; cdecl; export; abstract;
  674.     function GetHelpContext(var pdwHelpContext: Longint): HResult; virtual; cdecl; export; abstract;
  675.   end;
  676.  
  677.  
  678. { ICreateErrorInfo methods }
  679.  
  680.   ICreateErrorInfo = class(IUnknown)
  681.     function QueryInterface(const riid: IID; var ppvObj: Pointer): HResult; virtual; cdecl; export; abstract;
  682.     function AddRef: Longint; virtual; cdecl; export; abstract;
  683.     function Release: Longint; virtual; cdecl; export; abstract;
  684.     function SetGUID(const rguid: IID): HResult; virtual; cdecl; export; abstract;
  685.     function SetSource(szSource: POLESTR): HResult; virtual; cdecl; export; abstract;
  686.     function SetDescription(szDescription: POLESTR): HResult; virtual; cdecl; export; abstract;
  687.     function SetHelpFile(szHelpFile: POLESTR): HResult; virtual; cdecl; export; abstract;
  688.     function SetHelpContext(dwHelpContext: Longint): HResult; virtual; cdecl; export; abstract;
  689.   end;
  690.  
  691.  
  692. { ISupportErrorInfo methods }
  693.  
  694.   ISupportErrorInfo = class(IUnknown)
  695.     function QueryInterface(const riid: IID; var ppvObj: Pointer): HResult; virtual; cdecl; export; abstract;
  696.     function AddRef: Longint; virtual; cdecl; export; abstract;
  697.     function Release: Longint; virtual; cdecl; export; abstract;
  698.     function InterfaceSupportsErrorInfo(const riid: IID): HResult; virtual; cdecl; export; abstract;
  699.   end;
  700.  
  701. {---------------------------------------------------------------------}
  702. {                   IDispatch implementation support                  }
  703. {---------------------------------------------------------------------}
  704.  
  705.   PPARAMDATA = ^PARAMDATA;
  706.   PARAMDATA = record
  707.     szName: BSTR; { parameter name }
  708.     vt: VARTYPE; { parameter type }
  709.   end;
  710.  
  711.   PMETHODDATA = ^METHODDATA;
  712.   METHODDATA = record
  713.     szName: BSTR; { method name }
  714.     ppdata: PPARAMDATA; { pointer to an array of PARAMDATAs }
  715.     dispid: DISPID; { method ID }
  716.     iMeth: Integer; { method index }
  717.     cc: CALLCONV; { calling convention }
  718.     cArgs: Integer; { count of arguments }
  719.     wFlags: Word; { same wFlags as on IDispatch::Invoke() }
  720.     vtReturn: VARTYPE; 
  721.   end;
  722.  
  723.   PINTERFACEDATA = ^INTERFACEDATA;
  724.   INTERFACEDATA = record
  725.     pmethdata: PMETHODDATA; { pointer to an array of METHODDATAs }
  726.     cMembers: Integer; { count of members }
  727.   end;
  728.  
  729. {---------------------------------------------------------------------}
  730. {                            BSTR API                                 }
  731. {---------------------------------------------------------------------}
  732.  
  733. function SysAllocString(const p1: PCOLESTR): BSTR; 
  734. function SysReAllocString(var p1: BSTR; const p2: PCOLESTR): Integer; 
  735. function SysAllocStringLen(const p1: PCOLESTR; p2: Integer): BSTR; 
  736. function SysReAllocStringLen(var p1: BSTR; const p2: PCOLESTR; p3: Integer): Integer; 
  737. procedure SysFreeString(bstr: BSTR);  
  738. function SysStringLen(p1: BSTR): Word; 
  739.  
  740. {$IFDEF WIN32}
  741. function SysStringByteLen(p1: BSTR): Word;
  742. function SysAllocStringByteLen(psz: PChar; len: Word): BSTR;
  743. {$ENDIF}
  744.  
  745. {---------------------------------------------------------------------}
  746. {                            Time API                                 }
  747. {---------------------------------------------------------------------}
  748.  
  749. function DosDateTimeToVariantTime(wDosDate: Word; wDosTime: Word; var pvtime: DATE): Integer; 
  750. function VariantTimeToDosDateTime(vtime: DATE; var pwDosDate: Word; var pwDosTime: Word): Integer; 
  751.  
  752. {---------------------------------------------------------------------}
  753. {                          SafeArray API                              }
  754. {---------------------------------------------------------------------}
  755.  
  756. function SafeArrayAllocDescriptor(cDims: Integer; var ppsaOut: PSAFEARRAY): HResult; 
  757. function SafeArrayAllocData(var psa: SAFEARRAY): HResult; 
  758. function SafeArrayCreate(vt: VARTYPE; cDims: Integer; var rgsabound: SAFEARRAYBOUND): PInteger; 
  759. function SafeArrayDestroyDescriptor(var psa: SAFEARRAY): HResult; 
  760. function SafeArrayDestroyData(var psa: SAFEARRAY): HResult; 
  761. function SafeArrayDestroy(var psa: SAFEARRAY): HResult; 
  762. function SafeArrayRedim(var psa: SAFEARRAY; var psaboundNew: SAFEARRAYBOUND): HResult; 
  763. function SafeArrayGetDim(var psa: SAFEARRAY): Word; 
  764. function SafeArrayGetElemsize(var psa: SAFEARRAY): Word; 
  765. function SafeArrayGetUBound(var psa: SAFEARRAY; nDim: Integer; var plUbound: Longint): HResult;
  766. function SafeArrayGetLBound(var psa: SAFEARRAY; nDim: Integer; var plLbound: Longint): HResult; 
  767. function SafeArrayLock(var psa: SAFEARRAY): HResult; 
  768. function SafeArrayUnlock(var psa: SAFEARRAY): HResult; 
  769. function SafeArrayAccessData(var psa: SAFEARRAY; var ppvData: HResult): HResult; 
  770. function SafeArrayUnaccessData(var psa: SAFEARRAY): HResult; 
  771. function SafeArrayGetElement(var psa: SAFEARRAY; var rgIndices: Longint; pv: HResult): HResult; 
  772. function SafeArrayPutElement(var psa: SAFEARRAY; var rgIndices: Longint; pv: HResult): HResult; 
  773. function SafeArrayCopy(var psa: SAFEARRAY; var ppsaOut: PSAFEARRAY): HResult; 
  774. function SafeArrayPtrOfIndex(var psa: SAFEARRAY; var rgIndices: Longint; var ppvData: HResult): HResult; 
  775.  
  776. {---------------------------------------------------------------------}
  777. {                           VARIANT API                               }
  778. {---------------------------------------------------------------------}
  779.  
  780. procedure VariantInit(var VarVal: VARIANTARG);
  781. function VariantClear(var pvarg: VARIANTARG): HResult; 
  782. function VariantCopy(var pvargDest: VARIANTARG; var pvargSrc: VARIANTARG): HResult; 
  783. function VariantCopyInd(var pvarDest: VARIANT; var pvargSrc: VARIANTARG): HResult; 
  784. function VariantChangeType(var pvargDest: VARIANTARG; var pvarSrc: VARIANTARG;
  785.   wFlags: Word; vt: VARTYPE): HResult; 
  786. function VariantChangeTypeEx(var pvargDest: VARIANTARG; var pvarSrc: 
  787.   VARIANTARG; lcid: LCID; wFlags: Word; vt: VARTYPE): HResult; 
  788.  
  789. {---------------------------------------------------------------------}
  790. {                     VARTYPE Coercion API                            }
  791. {---------------------------------------------------------------------}
  792.  
  793. { Note: The routines that convert from a string are defined
  794.   to take a OLECHAR rather than a BSTR because no allocation is
  795.   required, and this makes the routines a bit more generic.
  796.   They may of course still be passed a BSTR as the strIn param. }
  797.  
  798. { Any of the coersion functions that converts either from or to a string
  799.   takes an additional lcid and dwFlags arguments. The lcid argument allows
  800.   locale specific parsing to occur.  The dwFlags allow additional function
  801.   specific condition to occur.  All function that accept the dwFlags argument
  802.   can include either 0 or LOCALE_NOUSEROVERRIDE flag. In addition, the
  803.   VarDateFromStr functions also accepts the VAR_TIMEVALUEONLY and 
  804.   VAR_DATEVALUEONLY flags }
  805.  
  806. function VarUI1FromI2(sIn: Integer; pbOut: PChar): HResult; 
  807. function VarUI1FromI4(lIn: Longint; pbOut: PChar): HResult; 
  808. function VarUI1FromR4(fltIn: Single; pbOut: PChar): HResult; 
  809. function VarUI1FromR8(dblIn: DATE; pbOut: PChar): HResult; 
  810. function VarUI1FromCy(cyIn: CY; pbOut: PChar): HResult; 
  811. function VarUI1FromDate(dateIn: DATE; pbOut: PChar): HResult; 
  812. function VarUI1FromStr(strIn: BSTR; lcid: LCID; dwFlags: Longint; pbOut: PChar): HResult; 
  813. function VarUI1FromDisp(var pdispIn: IDispatch; lcid: LCID; pbOut: PChar): HResult; 
  814. function VarUI1FromBool(boolIn: VARIANT_BOOL; pbOut: PChar): HResult; 
  815. function VarI2FromUI1(bIn: Byte; var psOut: Integer): HResult; 
  816. function VarI2FromI4(lIn: Longint; var psOut: Integer): HResult; 
  817. function VarI2FromR4(fltIn: Single; var psOut: Integer): HResult; 
  818. function VarI2FromR8(dblIn: DATE; var psOut: Integer): HResult; 
  819. function VarI2FromCy(cyIn: CY; var psOut: Integer): HResult; 
  820. function VarI2FromDate(dateIn: DATE; var psOut: Integer): HResult; 
  821. function VarI2FromStr(strIn: BSTR; lcid: LCID; dwFlags: Longint; var psOut: Integer): HResult; 
  822. function VarI2FromDisp(var pdispIn: IDispatch; lcid: LCID; var psOut: Integer): HResult; 
  823. function VarI2FromBool(boolIn: VARIANT_BOOL; var psOut: Integer): HResult; 
  824. function VarI4FromUI1(bIn: Byte; var plOut: Longint): HResult; 
  825. function VarI4FromI2(sIn: Integer; var plOut: Longint): HResult; 
  826. function VarI4FromR4(fltIn: Single; var plOut: Longint): HResult; 
  827. function VarI4FromR8(dblIn: DATE; var plOut: Longint): HResult; 
  828. function VarI4FromCy(cyIn: CY; var plOut: Longint): HResult; 
  829. function VarI4FromDate(dateIn: DATE; var plOut: Longint): HResult; 
  830. function VarI4FromStr(strIn: BSTR; lcid: LCID; dwFlags: Longint; var plOut: Longint): HResult; 
  831. function VarI4FromDisp(var pdispIn: IDispatch; lcid: LCID; var plOut: Longint): HResult; 
  832. function VarI4FromBool(boolIn: VARIANT_BOOL; var plOut: Longint): HResult; 
  833. function VarR4FromUI1(bIn: Byte; var pfltOut: Single): HResult; 
  834. function VarR4FromI2(sIn: Integer; var pfltOut: Single): HResult; 
  835. function VarR4FromI4(lIn: Longint; var pfltOut: Single): HResult; 
  836. function VarR4FromR8(dblIn: DATE; var pfltOut: Single): HResult; 
  837. function VarR4FromCy(cyIn: CY; var pfltOut: Single): HResult; 
  838. function VarR4FromDate(dateIn: DATE; var pfltOut: Single): HResult; 
  839. function VarR4FromStr(strIn: BSTR; lcid: LCID; dwFlags: Longint; var pfltOut: Single): HResult; 
  840. function VarR4FromDisp(var pdispIn: IDispatch; lcid: LCID; var pfltOut: Single): HResult; 
  841. function VarR4FromBool(boolIn: VARIANT_BOOL; var pfltOut: Single): HResult; 
  842. function VarR8FromUI1(bIn: Byte; var pdblOut: DATE): HResult; 
  843. function VarR8FromI2(sIn: Integer; var pdblOut: DATE): HResult; 
  844. function VarR8FromI4(lIn: Longint; var pdblOut: DATE): HResult; 
  845. function VarR8FromR4(fltIn: Single; var pdblOut: DATE): HResult; 
  846. function VarR8FromCy(cyIn: CY; var pdblOut: DATE): HResult; 
  847. function VarR8FromDate(dateIn: DATE; var pdblOut: DATE): HResult; 
  848. function VarR8FromStr(strIn: BSTR; lcid: LCID; dwFlags: Longint; var pdblOut: DATE): HResult; 
  849. function VarR8FromDisp(var pdispIn: IDispatch; lcid: LCID; var pdblOut: DATE): HResult; 
  850. function VarR8FromBool(boolIn: VARIANT_BOOL; var pdblOut: DATE): HResult; 
  851. function VarDateFromUI1(bIn: Byte; var pdateOut: DATE): HResult; 
  852. function VarDateFromI2(sIn: Integer; var pdateOut: DATE): HResult; 
  853. function VarDateFromI4(lIn: Longint; var pdateOut: DATE): HResult; 
  854. function VarDateFromR4(fltIn: Single; var pdateOut: DATE): HResult; 
  855. function VarDateFromR8(dblIn: DATE; var pdateOut: DATE): HResult; 
  856. function VarDateFromCy(cyIn: CY; var pdateOut: DATE): HResult; 
  857. function VarDateFromStr(strIn: BSTR; lcid: LCID; dwFlags: Longint; var pdateOut: DATE): HResult; 
  858. function VarDateFromDisp(var pdispIn: IDispatch; lcid: LCID; var pdateOut: DATE): HResult; 
  859. function VarDateFromBool(boolIn: VARIANT_BOOL; var pdateOut: DATE): HResult; 
  860. function VarCyFromUI1(bIn: Byte; var pcyOut: CY): HResult; 
  861. function VarCyFromI2(sIn: Integer; var pcyOut: CY): HResult; 
  862. function VarCyFromI4(lIn: Longint; var pcyOut: CY): HResult; 
  863. function VarCyFromR4(fltIn: Single; var pcyOut: CY): HResult; 
  864. function VarCyFromR8(dblIn: DATE; var pcyOut: CY): HResult; 
  865. function VarCyFromDate(dateIn: DATE; var pcyOut: CY): HResult; 
  866. function VarCyFromStr(strIn: BSTR; lcid: LCID; dwFlags: Longint; var pcyOut: CY): HResult; 
  867. function VarCyFromDisp(var pdispIn: IDispatch; lcid: LCID; var pcyOut: CY): HResult; 
  868. function VarCyFromBool(boolIn: VARIANT_BOOL; var pcyOut: CY): HResult; 
  869. function VarBstrFromUI1(bVal: Byte; lcid: LCID; dwFlags: Longint; var pbstrOut: BSTR): HResult; 
  870. function VarBstrFromI2(iVal: Integer; lcid: LCID; dwFlags: Longint; var pbstrOut: BSTR): HResult; 
  871. function VarBstrFromI4(lIn: Longint; lcid: LCID; dwFlags: Longint; var pbstrOut: BSTR): HResult; 
  872. function VarBstrFromR4(fltIn: Single; lcid: LCID; dwFlags: Longint; var pbstrOut: BSTR): HResult; 
  873. function VarBstrFromR8(dblIn: DATE; lcid: LCID; dwFlags: Longint; var pbstrOut: BSTR): HResult; 
  874. function VarBstrFromCy(cyIn: CY; lcid: LCID; dwFlags: Longint; var pbstrOut: BSTR): HResult; 
  875. function VarBstrFromDate(dateIn: DATE; lcid: LCID; dwFlags: Longint; var pbstrOut: BSTR): HResult; 
  876. function VarBstrFromDisp(var pdispIn: IDispatch; lcid: LCID; dwFlags: Longint; var pbstrOut: BSTR): HResult; 
  877. function VarBstrFromBool(boolIn: VARIANT_BOOL; lcid: LCID; dwFlags: Longint; var pbstrOut: BSTR): HResult; 
  878. function VarBoolFromUI1(bIn: Byte; var pboolOut: VARIANT_BOOL): HResult; 
  879. function VarBoolFromI2(sIn: Integer; var pboolOut: VARIANT_BOOL): HResult; 
  880. function VarBoolFromI4(lIn: Longint; var pboolOut: VARIANT_BOOL): HResult; 
  881. function VarBoolFromR4(fltIn: Single; var pboolOut: VARIANT_BOOL): HResult; 
  882. function VarBoolFromR8(dblIn: DATE; var pboolOut: VARIANT_BOOL): HResult; 
  883. function VarBoolFromDate(dateIn: DATE; var pboolOut: VARIANT_BOOL): HResult; 
  884. function VarBoolFromCy(cyIn: CY; var pboolOut: VARIANT_BOOL): HResult; 
  885. function VarBoolFromStr(strIn: BSTR; lcid: LCID; dwFlags: Longint; var pboolOut: VARIANT_BOOL): HResult; 
  886. function VarBoolFromDisp(var pdispIn: IDispatch; lcid: LCID; var pboolOut: VARIANT_BOOL): HResult; 
  887.  
  888. {---------------------------------------------------------------------}
  889. {                         TypeInfo APIs                               }
  890. {---------------------------------------------------------------------}
  891.  
  892. { compute a 32bit hash value for the given name  based on the lcid and system kind }
  893. { Macro to compute a 32bit hash value for the given name based on the LCID }
  894. function LHashValOfName(lcid: LCID; const szName: PCOLESTR): Longint; 
  895.  
  896. { compute a 16bit hash value from 32 bit hash value }
  897. function WHashValOfLHashVal(lhashval: LongInt): Word;
  898.  
  899. { Check if the hash values are compatible. }
  900. function IsHashValCompatible(lhashval1: LongInt; lhashval2: LongInt): Boolean;
  901.  
  902.  
  903. function LHashValOfNameSys(syskind: SYSKIND; lcid: LCID; const szName: PCOLESTR): Longint; 
  904. function LoadTypeLib(const szFile: PCOLESTR; var pptlib: ITypeLib): HResult;
  905. function LoadRegTypeLib(const rguid: IID; wVerMajor: Word; wVerMinor: Word; 
  906.   lcid: LCID; var pptlib: ITypeLib): HResult; 
  907. function QueryPathOfRegTypeLib(const guid: IID; wMaj: Word; wMin: Word; lcid: LCID; 
  908.   var lpbstrPathName: BSTR): HResult; 
  909. function RegisterTypeLib(ptlib: ITypeLib; szFullPath: BSTR; szHelpDir: BSTR): HResult; 
  910. function CreateTypeLib(syskind: SYSKIND; const szFile: PCOLESTR; var ppctlib: ICreateTypeLib): HResult; 
  911.  
  912. { ISupportErrorInfo methods }
  913. function SetErrorInfo(dwReserved: Longint; perrinfo: IErrorInfo): HResult; 
  914. function GetErrorInfo(dwReserved: Longint; var pperrinfo: IErrorInfo): HResult;
  915. function CreateErrorInfo(var pperrinfo: ICreateErrorInfo): HResult; 
  916.  
  917. { IDispatch implementation support }
  918. function DispGetParam(var pdispparams: DISPPARAMS; position: Integer; vtTarg: 
  919.   VARTYPE; var pvarResult: VARIANT; var puArgErr: Integer): HResult; 
  920. function DispGetIDsOfNames(ptinfo: ITypeInfo; var rgszNames: BSTR; 
  921.   cNames: Integer; var rgdispid: DISPID): HResult; 
  922. function DispInvoke(_this: HResult; ptinfo: ITypeInfo; dispidMember: DISPID; 
  923.   wFlags: Word; var pparams: DISPPARAMS; var pvarResult: VARIANT; 
  924.   var pexcepinfo: EXCEPINFO; var puArgErr: Integer): HResult; 
  925. function CreateDispTypeInfo(var pidata: INTERFACEDATA; lcid: LCID; 
  926.   var pptinfo: ITypeInfo): HResult; 
  927. function CreateStdDispatch(var punkOuter: IUnknown; pvThis: HResult; 
  928.   ptinfo: ITypeInfo; var ppunkStdDisp: IUnknown): HResult; 
  929.  
  930. {---------------------------------------------------------------------}
  931. {                    Active Object Registration API                   }
  932. {---------------------------------------------------------------------}
  933.  
  934. function RegisterActiveObject(var punk: IUnknown; const rclsid: IID; 
  935.   dwFlags: Longint; var pdwRegister: Longint): HResult; 
  936. function RevokeActiveObject(dwRegister: Longint; pvReserved: HResult): HResult;
  937. function GetActiveObject(const rclsid: IID; pvReserved: HResult; var ppunk: IUnknown): HResult; 
  938.  
  939. {---------------------------------------------------------------------}
  940. {                           MISC API                                  }
  941. {---------------------------------------------------------------------}
  942.  
  943. function OaBuildVersion: Longint; 
  944.  
  945.  
  946. implementation
  947.